Generative Adversarial Network (GAN) একটি অত্যন্ত শক্তিশালী এবং জনপ্রিয় Deep Learning মডেল যা দুইটি নিউরাল নেটওয়ার্ক (Generator এবং Discriminator) এর মধ্যে প্রতিযোগিতা (adversarial training) তৈরি করে। এই মডেলটি মূলত Generative মডেল হিসেবে কাজ করে, যেখানে Generator নতুন ডেটা তৈরি করার চেষ্টা করে এবং Discriminator সেগুলোকে আসল ডেটা থেকে আলাদা করার চেষ্টা করে।
GAN মডেল প্রশিক্ষণের সময়, Generator এবং Discriminator একে অপরকে উন্নত করতে থাকে যতক্ষণ না Generator অজানা ডেটা তৈরি করতে পারে যা Discriminator সঠিকভাবে আলাদা করতে পারে না।
GAN এর মূল উপাদান:
- Generator (G):
- এটি নতুন ডেটা তৈরি করার চেষ্টা করে, যেমন ছবি, সঙ্গীত, টেক্সট ইত্যাদি। Generator সাধারণত একটি র্যান্ডম নইজ (noise) ইনপুট নিয়ে একটি বাস্তবসম্মত আউটপুট তৈরি করার চেষ্টা করে।
- Discriminator (D):
- এটি real এবং fake ডেটার মধ্যে পার্থক্য চিহ্নিত করার জন্য প্রশিক্ষিত হয়। Discriminator এর কাজ হলো শনাক্ত করা যে, একটি ডেটা আসল না কি Generator দ্বারা তৈরি করা (fake)।
GAN মডেল ট্রেনিং এবং ইভ্যালুয়েশন প্রক্রিয়া:
ধাপ ১: ডেটা প্রস্তুতি (Data Preparation)
GAN মডেলকে ট্রেন করার জন্য প্রথমে আপনাকে একটি ডেটাসেট প্রিপেয়ার করতে হবে। সাধারণত, এমপিটি-ডেটা (MNIST, CIFAR-10, বা অন্যান্য ইমেজ ডেটাসেট) ব্যবহার করা হয়।
import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt
# MNIST ডেটাসেট লোড করা
(X_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
# ডেটা প্রিপ্রসেসিং
X_train = X_train / 127.5 - 1.0 # Normalizing images to [-1, 1]
X_train = np.expand_dims(X_train, axis=-1)
ধাপ ২: Generator এবং Discriminator তৈরি করা (Building Generator and Discriminator)
- Generator: একটি সিম্পল ফিডফরওয়ার্ড নিউরাল নেটওয়ার্ক তৈরি করা হয় যা র্যান্ডম নইজ (noise) ইনপুট নিয়ে একটি নতুন ছবি তৈরি করবে।
def build_generator():
model = tf.keras.Sequential([
layers.Dense(128, activation='relu', input_shape=(100,)),
layers.Dense(256, activation='relu'),
layers.Dense(512, activation='relu'),
layers.Dense(1024, activation='relu'),
layers.Dense(28 * 28 * 1, activation='tanh'),
layers.Reshape((28, 28, 1))
])
return model
- Discriminator: এটি একটি কনভোলিউশনাল নিউরাল নেটওয়ার্ক (CNN) যা ছবি নিয়ে সেটি আসল না কি ফেক তা শনাক্ত করবে।
def build_discriminator():
model = tf.keras.Sequential([
layers.Conv2D(64, kernel_size=3, strides=2, padding='same', input_shape=(28, 28, 1)),
layers.LeakyReLU(alpha=0.2),
layers.Conv2D(128, kernel_size=3, strides=2, padding='same'),
layers.LeakyReLU(alpha=0.2),
layers.Flatten(),
layers.Dense(1, activation='sigmoid')
])
return model
ধাপ ৩: GAN কম্পাইল এবং ট্রেনিং (Compiling and Training GAN)
GAN মডেলটি দুটি ভিন্ন অংশে বিভক্ত: Generator এবং Discriminator। আমরা binary cross-entropy লস ফাংশন ব্যবহার করব এবং Adam optimizer দিয়ে প্রশিক্ষণ করব।
- Loss Function: Generator এবং Discriminator এর জন্য লস ফাংশন পৃথক। Discriminator এর কাজ হলো আসল এবং ফেক ছবি আলাদা করা এবং Generator এর কাজ হলো ফেক ছবি তৈরি করা যা Discriminator সঠিকভাবে আলাদা করতে না পারে।
- Optimizer: Adam optimizer সাধারণত GAN মডেলের জন্য সবচেয়ে কার্যকরী।
# Build Generator and Discriminator
generator = build_generator()
discriminator = build_discriminator()
# Define the GAN Model
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Make the discriminator not trainable while training the GAN
discriminator.trainable = False
# GAN model combines both Generator and Discriminator
gan_input = layers.Input(shape=(100,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = tf.keras.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')
ধাপ ৪: ট্রেনিং লুপ (Training Loop)
- প্রথমে Generator একটি ফেক ছবি তৈরি করে।
- তারপর Discriminator সেই ছবিটি আসল বা ফেক চিহ্নিত করার চেষ্টা করে।
- Discriminator কে 50% আসল এবং 50% ফেক ছবি দেখানো হয়, এবং তাদের পারফরম্যান্স অনুযায়ী প্রশিক্ষিত হয়।
- GAN প্রশিক্ষণের সময়, আমরা Discriminator এবং Generator উভয়কেই আলাদা আলাদা ভাবে ট্রেন করি।
import os
# Hyperparameters
epochs = 10000
batch_size = 64
half_batch = batch_size // 2
# Training loop
for epoch in range(epochs):
# Train Discriminator
idx = np.random.randint(0, X_train.shape[0], half_batch)
real_images = X_train[idx]
fake_images = generator.predict(np.random.randn(half_batch, 100))
d_loss_real = discriminator.train_on_batch(real_images, np.ones((half_batch, 1)))
d_loss_fake = discriminator.train_on_batch(fake_images, np.zeros((half_batch, 1)))
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train Generator
noise = np.random.randn(batch_size, 100)
g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))
# Print the progress
if epoch % 100 == 0:
print(f"{epoch} [D loss: {d_loss[0]} | G loss: {g_loss}]")
ধাপ ৫: ইভ্যালুয়েশন (Evaluation)
GAN মডেলটির ইভ্যালুয়েশন করতে হবে প্রডিউসড ছবি বিশ্লেষণ করে এবং আসল ছবির সাথে তুলনা করে:
- Generated Image Visualization: প্রতি ইটারেশনে কিছু ছবি তৈরি করে সেগুলোকে দেখানো হয়।
- Inception Score (IS): এটি একাধিক ছবির মাধ্যমে উৎপন্ন ছবির গুণমান পরিমাপ করতে ব্যবহৃত হয়।
- Frechet Inception Distance (FID): এটি আরও উন্নত এবং কার্যকরী মেট্রিক যা GAN এর পারফরম্যান্স মূল্যায়ন করতে ব্যবহৃত হয়।
# Visualize generated images after training
def plot_generated_images(epoch, generator, examples=10, dim=(1, 10), figsize=(10, 1)):
noise = np.random.randn(examples, 100)
generated_images = generator.predict(noise)
plt.figure(figsize=figsize)
for i in range(examples):
plt.subplot(dim[0], dim[1], i + 1)
plt.imshow(generated_images[i], interpolation='nearest', cmap='gray')
plt.axis('off')
plt.tight_layout()
plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
plt.close()
# Generate images at specified epochs
plot_generated_images(epochs, generator)
উপসংহার:
- GAN (Generative Adversarial Network) একটি শক্তিশালী মডেল যা দুইটি প্রতিদ্বন্দ্বী নিউরাল নেটওয়ার্কের মাধ্যমে কাজ করে: Generator এবং Discriminator।
- Training এ আমরা Generator এবং Discriminator দুটি আলাদা ভাবে ট্রেন করি এবং মডেলটি ধীরে ধীরে উন্নত হয়।
- Evaluation এ, আমরা generated images এর গুণমান মূল্যায়ন করি এবং বিভিন্ন metrics যেমন Inception Score এবং FID ব্যবহার করে মডেলটির কার্যকারিতা যাচাই করি।
Content added By
Read more
